/**
 * @file simulation.c
 * @brief 覆冰监测系统模拟模块实现
 * @version 2.1
 * @date 2023-05-25
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <unistd.h>

#include "simulation.h"
#include "common_defs.h"
#include "system_utils.h"
#include "ice_calculation.h"

// 风速阈值 
extern const float HIGH_WIND_THRESHOLD;
extern const float EXTREME_WIND_THRESHOLD;

// 全局控制变量
extern volatile bool g_running;
extern RunMode g_run_mode;
extern SampleMode g_sample_mode;

// 季节和冰阶段持续时间配置(毫秒)
#define CYCLE_DURATION_MS          (6 * 60 * 1000)    // 6分钟完整周期
#define WINTER_DURATION_MS         (3 * 60 * 1000)    // 3分钟冬季
#define NON_WINTER_DURATION_MS     (3 * 60 * 1000)    // 3分钟春夏秋
#define SPRING_DURATION_MS         (60 * 1000)        // 60秒春季
#define SUMMER_DURATION_MS         (60 * 1000)        // 60秒夏季
#define AUTUMN_DURATION_MS         (60 * 1000)        // 60秒秋季

// 冬季覆冰阶段持续时间配置(毫秒)
#define ICE_NONE_START_DURATION_MS (30 * 1000)        // 30秒无覆冰(初始)
#define ICE_GROWTH_DURATION_MS     (60 * 1000)        // 1分钟覆冰增长
#define ICE_STABLE_DURATION_MS     (60 * 1000)        // 1分钟覆冰保持
#define ICE_REDUCTION_DURATION_MS  (45 * 1000)        // 45秒覆冰减少
#define ICE_NONE_END_DURATION_MS   (25 * 1000)        // 25秒无覆冰(结束)

// 全局模拟数据实例
static SimulationData g_simulation_data = {
    // 默认值
    .temperature = -2.0f,
    .humidity = 85.0f,
    .wind_speed = 4.5f,
    .wind_direction = 45.0f,
    .equivalent_ice_thickness = 0.0f,
    .equivalent_tension = 0.0f,
    .real_ice_thickness = 0.0f,
    .simulation_phase = 0,
    .phase_counter = 0,
    .max_tension_increase = 0.0f,
    // 新增字段初始值
    .current_season = SEASON_WINTER,
    .ice_phase = ICE_PHASE_NONE_START,
    .season_start_time = 0,
    .phase_start_time = 0,
    .target_ice_thickness = 0.0f
};

// 季节特征参数表
typedef struct {
    float base_temperature;    // 基础温度(°C)
    float temp_variation;      // 温度变化范围(±°C)
    float base_humidity;       // 基础湿度(%)
    float humidity_variation;  // 湿度变化范围(±%)
    float base_wind_speed;     // 基础风速(m/s)
    float wind_variation;      // 风速变化范围(±m/s)
    
    // 视觉特征参数 - 新增
    float brightness;          // 亮度系数(0.5-1.5)
    float contrast;            // 对比度系数(0.8-1.2)
    float scene_color;         // 场景色调(0=冷色调, 1=暖色调)
    float fog_density;         // 雾气密度(0-1)
    float visible_range;       // 可见距离系数(0.5-1.5)
} SeasonParameters;

// 各季节参数配置
static const SeasonParameters g_season_params[SEASON_COUNT] = {
    // 春季
    {
        .base_temperature = 8.0f,
        .temp_variation = 4.0f,
        .base_humidity = 65.0f,
        .humidity_variation = 10.0f,
        .base_wind_speed = 3.5f,
        .wind_variation = 2.0f,
        // 新增视觉特征 - 春季特征：明亮，略微雾气，色调适中，可见度较好
        .brightness = 1.2f,
        .contrast = 1.0f,
        .scene_color = 0.6f,  // 略微暖色调
        .fog_density = 0.3f,  // 轻微雾气
        .visible_range = 1.2f // 可见度较好
    },
    // 夏季
    {
        .base_temperature = 25.0f,
        .temp_variation = 5.0f,
        .base_humidity = 55.0f,
        .humidity_variation = 15.0f,
        .base_wind_speed = 2.5f,
        .wind_variation = 1.5f,
        // 新增视觉特征 - 夏季特征：非常明亮，高对比度，暖色调，少雾气，可见度好
        .brightness = 1.5f,
        .contrast = 1.2f,
        .scene_color = 0.8f,  // 明显暖色调
        .fog_density = 0.1f,  // 很少雾气
        .visible_range = 1.5f // 可见度最好
    },
    // 秋季
    {
        .base_temperature = 12.0f,
        .temp_variation = 4.0f,
        .base_humidity = 70.0f,
        .humidity_variation = 10.0f,
        .base_wind_speed = 4.0f,
        .wind_variation = 2.0f,
        // 新增视觉特征 - 秋季特征：中等亮度，对比度略高，暖色调，中等雾气，适中可见度
        .brightness = 1.0f,
        .contrast = 1.1f,
        .scene_color = 0.7f,  // 较暖色调
        .fog_density = 0.4f,  // 中等雾气
        .visible_range = 1.0f // 标准可见度
    },
    // 冬季
    {
        .base_temperature = -5.0f,
        .temp_variation = 3.0f,
        .base_humidity = 85.0f,
        .humidity_variation = 8.0f,
        .base_wind_speed = 5.0f,
        .wind_variation = 2.5f,
        // 新增视觉特征 - 冬季特征：亮度低，对比度低，冷色调，较多雾气，可见度差
        .brightness = 0.7f,
        .contrast = 0.9f,
        .scene_color = 0.2f,  // 明显冷色调
        .fog_density = 0.7f,  // 较多雾气
        .visible_range = 0.7f // 可见度较差
    }
};

// 冬季覆冰阶段参数配置
typedef struct {
    float temp_offset;         // 温度偏移(°C)
    float humidity_offset;     // 湿度偏移(%)
    float wind_offset;         // 风速偏移(m/s)
    float target_ice_min;      // 目标最小覆冰厚度(mm)
    float target_ice_max;      // 目标最大覆冰厚度(mm)
} IcePhaseParameters;

// 各覆冰阶段参数配置
static const IcePhaseParameters g_ice_phase_params[ICE_PHASE_COUNT] = {
    // 无覆冰(初始)
    {
        .temp_offset = 2.0f,       // 较温暖
        .humidity_offset = -5.0f,  // 较干燥
        .wind_offset = -1.0f,      // 较小风速
        .target_ice_min = 0.0f,
        .target_ice_max = 0.0f
    },
    // 覆冰增长
    {
        .temp_offset = -2.0f,      // 较冷
        .humidity_offset = 8.0f,   // 较湿润
        .wind_offset = 1.5f,       // 风速适中
        .target_ice_min = 10.0f,
        .target_ice_max = 30.0f
    },
    // 覆冰保持
    {
        .temp_offset = -4.0f,      // 更冷
        .humidity_offset = 12.0f,  // 更湿润
        .wind_offset = 2.0f,       // 风速较大
        .target_ice_min = 30.0f,
        .target_ice_max = 50.0f
    },
    // 覆冰减少
    {
        .temp_offset = 1.0f,       // 回暖
        .humidity_offset = -2.0f,  // 干燥
        .wind_offset = 0.0f,       // 风速正常
        .target_ice_min = 5.0f,
        .target_ice_max = 15.0f
    },
    // 无覆冰(结束)
    {
        .temp_offset = 3.0f,       // 更温暖
        .humidity_offset = -8.0f,  // 更干燥
        .wind_offset = -1.5f,      // 风速较小
        .target_ice_min = 0.0f,
        .target_ice_max = 0.0f
    }
};

// 程序启动时间
static uint64_t g_simulation_start_time = 0;

// 添加记录上一次覆冰厚度的全局变量，用于状态判断
static float g_prev_ice_thickness = 0.0f;

// 添加从uart_handler.c移植的传感器模拟数据结构
static SensorMockData g_sensor_mock_data = {
    .wind_speed = 5.0f,
    .wind_direction = 45.0f,
    .temperature = -5.0f,
    .humidity = 85.0f,
    .tension1 = 3.00f,
    .tension2 = 3.05f,
    .battery_level = 90.0f,
    .voltage = 23.5f,
    .signal_strength = -65,
    .use_random = true
};

// 添加全局变量用于跟踪环境参数的变化
static float g_prev_temperature = 0.0f;
static float g_prev_humidity = 0.0f;
static float g_prev_wind_speed = 0.0f;
static float g_prev_tension1 = 1000.0f;  // 添加上一次拉力值追踪
static float g_prev_tension2 = 1000.0f;  // 添加上一次拉力值追踪

// 定义覆冰厚度上限常量和最大安全变化率
static const float MAX_ICE_THICKNESS = 48.0f;  // 降低上限，原为55.0mm
static const float MAX_THICKNESS_CHANGE = 0.2f; // 降低每次最大厚度变化，原为0.3f
static const float MAX_TEMP_CHANGE = 0.2f;      // 降低每次最大温度变化，原为0.3f
static const float MAX_HUMIDITY_CHANGE = 1.0f;  // 降低每次最大湿度变化，原为1.5f
static const float MAX_WIND_CHANGE = 0.5f;      // 降低每次最大风速变化，原为0.8f
static const float MAX_TENSION_CHANGE = 3.0f;   // 新增：最大拉力变化值(N)

/**
 * @brief 初始化模拟模块
 * 
 * @return int 成功返回0，失败返回非0值
 */
int init_simulation(void) {
    // 记录模拟启动时间
    g_simulation_start_time = get_timestamp_ms();
    
    // 重置模拟数据到默认状态
    reset_simulation_data();
    
    // 初始化随机数发生器
    srand((unsigned int)time(NULL));
    
    log_message(LOG_LEVEL_INFO, "模拟模块初始化完成");
    return 0;
}

/**
 * @brief 清理模拟模块
 */
void cleanup_simulation(void) {
    // 目前无需特殊清理操作
    log_message(LOG_LEVEL_INFO, "模拟模块清理完成");
}

/**
 * @brief 获取当前模拟数据
 * 
 * @return const SimulationData* 模拟数据指针（只读）
 */
const SimulationData* get_simulation_data(void) {
    return &g_simulation_data;
}

/**
 * @brief 设置模拟数据
 * 
 * @param data 模拟数据指针
 */
void set_simulation_data(const SimulationData *data) {
    if (data != NULL) {
        memcpy(&g_simulation_data, data, sizeof(SimulationData));
    }
}

/**
 * @brief 重置模拟数据到默认状态
 */
void reset_simulation_data(void) {
    uint64_t current_time = get_timestamp_ms();
    
    // 重置为默认值
    g_simulation_data.temperature = -2.0f;
    g_simulation_data.humidity = 85.0f;
    g_simulation_data.wind_speed = 4.5f;
    g_simulation_data.wind_direction = 45.0f;
    g_simulation_data.equivalent_ice_thickness = 0.0f;  // 初始无覆冰
    g_simulation_data.equivalent_tension = 0.0f;
    g_simulation_data.real_ice_thickness = 0.0f;  // 初始无覆冰
    g_simulation_data.simulation_phase = 0;
    g_simulation_data.phase_counter = 0;
    g_simulation_data.max_tension_increase = 0.0f;
    
    // 初始化新增字段
    g_simulation_data.current_season = SEASON_WINTER;
    g_simulation_data.ice_phase = ICE_PHASE_NONE_START;
    g_simulation_data.season_start_time = current_time;
    g_simulation_data.phase_start_time = current_time;
    g_simulation_data.target_ice_thickness = 0.0f;
    
    // 重置历史厚度
    g_prev_ice_thickness = 0.0f;
    
    log_message(LOG_LEVEL_INFO, "模拟数据已重置: 进入冬季-无覆冰初始阶段");
}

/**
 * @brief 更新四季循环模拟状态
 * 
 * @param current_time 当前时间戳(毫秒)
 */
void update_season_cycle(uint64_t current_time) {
    // 计算从程序启动开始经过的循环周期数
    uint64_t elapsed_ms = current_time - g_simulation_start_time;
    uint64_t cycle_position = elapsed_ms % CYCLE_DURATION_MS;
    
    // 确定当前应该处于哪个季节
    SeasonType new_season;
    if (cycle_position < WINTER_DURATION_MS) {
        // 3分钟冬季
        new_season = SEASON_WINTER;
    } else {
        // 2分钟其他季节(春季、夏季、秋季)
        uint64_t non_winter_position = cycle_position - WINTER_DURATION_MS;
        
        if (non_winter_position < SPRING_DURATION_MS) {
            new_season = SEASON_SPRING;
        } else if (non_winter_position < SPRING_DURATION_MS + SUMMER_DURATION_MS) {
            new_season = SEASON_SUMMER;
        } else {
            new_season = SEASON_AUTUMN;
        }
    }
    
    // 如果季节发生变化，记录新季节的开始时间
    if (new_season != g_simulation_data.current_season) {
        g_simulation_data.current_season = new_season;
        g_simulation_data.season_start_time = current_time;
        
        const char* season_names[] = {"春季", "夏季", "秋季", "冬季"};
        log_message(LOG_LEVEL_INFO, "季节变更: 进入%s", season_names[new_season]);
        
        // 如果进入冬季，初始化为冬季第一阶段
        if (new_season == SEASON_WINTER) {
            g_simulation_data.ice_phase = ICE_PHASE_NONE_START;
            g_simulation_data.phase_start_time = current_time;
            g_simulation_data.target_ice_thickness = 0.0f;
            log_message(LOG_LEVEL_INFO, "冬季初始化: 无覆冰初始阶段");
        }
    }
    
    // 如果在冬季，检查并更新覆冰阶段
    if (new_season == SEASON_WINTER) {
        update_winter_ice_phase(current_time);
    }
}

/**
 * @brief 更新冬季覆冰阶段
 * 
 * @param current_time 当前时间戳(毫秒)
 */
void update_winter_ice_phase(uint64_t current_time) {
    // 计算当前阶段已经持续的时间
    uint64_t phase_elapsed = current_time - g_simulation_data.phase_start_time;
    
    // 检查是否需要切换到下一个阶段
    bool phase_changed = false;
    IcePhaseType new_phase = g_simulation_data.ice_phase;
    
    switch (g_simulation_data.ice_phase) {
        case ICE_PHASE_NONE_START:
            if (phase_elapsed >= ICE_NONE_START_DURATION_MS) {
                new_phase = ICE_PHASE_GROWTH;
                phase_changed = true;
            }
            break;
            
        case ICE_PHASE_GROWTH:
            if (phase_elapsed >= ICE_GROWTH_DURATION_MS) {
                new_phase = ICE_PHASE_STABLE;
                phase_changed = true;
            }
            break;
            
        case ICE_PHASE_STABLE:
            if (phase_elapsed >= ICE_STABLE_DURATION_MS) {
                new_phase = ICE_PHASE_REDUCTION;
                phase_changed = true;
            }
            break;
            
        case ICE_PHASE_REDUCTION:
            if (phase_elapsed >= ICE_REDUCTION_DURATION_MS) {
                new_phase = ICE_PHASE_NONE_END;
                phase_changed = true;
            }
            break;
            
        case ICE_PHASE_NONE_END:
            // 最后阶段，保持直到冬季结束
            break;
            
        default:
            // 默认情况，重置为第一阶段
            new_phase = ICE_PHASE_NONE_START;
            phase_changed = true;
            break;
    }
    
    // 如果阶段发生变化，更新阶段信息
    if (phase_changed) {
        g_simulation_data.ice_phase = new_phase;
        g_simulation_data.phase_start_time = current_time;
        
        // 设置新阶段的目标覆冰厚度
        float min_thickness = g_ice_phase_params[new_phase].target_ice_min;
        float max_thickness = g_ice_phase_params[new_phase].target_ice_max;
        
        if (max_thickness > min_thickness) {
            // 在目标范围内随机选择一个厚度，使覆冰过程更自然
            g_simulation_data.target_ice_thickness = min_thickness + 
                ((float)rand() / RAND_MAX) * (max_thickness - min_thickness);
        } else {
            g_simulation_data.target_ice_thickness = min_thickness;
        }
        
        const char* phase_names[] = {
            "无覆冰初始", "覆冰增长", "覆冰保持", "覆冰减少", "无覆冰结束"
        };
        
        log_message(LOG_LEVEL_INFO, "冬季覆冰阶段变更: %s，目标厚度: %.2f mm", 
                    phase_names[new_phase], g_simulation_data.target_ice_thickness);
    }
}

/**
 * @brief 更新模拟环境，根据季节和阶段生成平滑变化的环境参数
 */
void update_simulation_environment() {
    uint64_t current_time = get_timestamp_ms();
    
    // 更新季节和覆冰阶段
    update_season_cycle(current_time);
    
    // 获取当前季节的基础参数
    const SeasonParameters* season_params = &g_season_params[g_simulation_data.current_season];
    
    // 如果是冬季，考虑当前覆冰阶段的额外影响
    float temp_offset = 0.0f;
    float humidity_offset = 0.0f;
    float wind_offset = 0.0f;
    
    if (g_simulation_data.current_season == SEASON_WINTER) {
        const IcePhaseParameters* phase_params = &g_ice_phase_params[g_simulation_data.ice_phase];
        temp_offset = phase_params->temp_offset;
        humidity_offset = phase_params->humidity_offset;
        wind_offset = phase_params->wind_offset;
    }
    
    // 计算目标环境参数
    float target_temp = season_params->base_temperature + temp_offset;
    float target_humidity = season_params->base_humidity + humidity_offset;
    float target_wind = season_params->base_wind_speed + wind_offset;
    
    // 添加随机变化，但降低变化幅度以避免异常
    float temp_variation = ((float)rand() / RAND_MAX * 1.0f - 0.5f) * season_params->temp_variation; // 进一步减小变化幅度
    float humid_variation = ((float)rand() / RAND_MAX * 1.0f - 0.5f) * season_params->humidity_variation;
    float wind_variation = ((float)rand() / RAND_MAX * 1.0f - 0.5f) * season_params->wind_variation;
    
    target_temp += temp_variation;
    target_humidity += humid_variation;
    target_wind += wind_variation;
    
    // 避免生成极端天气条件，限制温度和风速在合理范围内
    // 避免触发数据融合的极端天气警告
    if (target_temp < -19.0f) target_temp = -19.0f + ((float)rand() / RAND_MAX) * 2.0f; // 限制最低温度
    if (target_wind > 23.0f) target_wind = 23.0f - ((float)rand() / RAND_MAX) * 2.0f;   // 限制最大风速
    
    // 限制湿度范围
    if (target_humidity > 95.0f) target_humidity = 95.0f;
    if (target_humidity < 30.0f) target_humidity = 30.0f;
    
    // 限制风速范围
    if (target_wind < 0.5f) target_wind = 0.5f;
    
    // 平滑过渡到目标值(每次更新最多变化约0.5-2%，确保平滑)
    g_simulation_data.temperature = g_simulation_data.temperature * 0.98f + target_temp * 0.02f;
    g_simulation_data.humidity = g_simulation_data.humidity * 0.98f + target_humidity * 0.02f;
    g_simulation_data.wind_speed = g_simulation_data.wind_speed * 0.97f + target_wind * 0.03f;
    
    // 限制单次变化幅度，防止突变触发异常检测
    float temp_change = g_simulation_data.temperature - g_prev_temperature;
    if (fabs(temp_change) > MAX_TEMP_CHANGE) {
        g_simulation_data.temperature = g_prev_temperature + (temp_change > 0 ? MAX_TEMP_CHANGE : -MAX_TEMP_CHANGE);
    }
    
    // 限制湿度变化
    float humid_change = g_simulation_data.humidity - g_prev_humidity;
    if (fabs(humid_change) > MAX_HUMIDITY_CHANGE) {
        g_simulation_data.humidity = g_prev_humidity + (humid_change > 0 ? MAX_HUMIDITY_CHANGE : -MAX_HUMIDITY_CHANGE);
    }
    
    // 限制风速变化
    float wind_change = g_simulation_data.wind_speed - g_prev_wind_speed;
    if (fabs(wind_change) > MAX_WIND_CHANGE) {
        g_simulation_data.wind_speed = g_prev_wind_speed + (wind_change > 0 ? MAX_WIND_CHANGE : -MAX_WIND_CHANGE);
    }
    
    // 保存当前值用于下次比较
    g_prev_temperature = g_simulation_data.temperature;
    g_prev_humidity = g_simulation_data.humidity;
    g_prev_wind_speed = g_simulation_data.wind_speed;
    
    // 风向变化更随机，但也要平滑
    float wind_dir_change = ((float)rand() / RAND_MAX * 10.0f - 5.0f); // 减小为±5°，原为±7.5°
    g_simulation_data.wind_direction += wind_dir_change;
    
    // 确保风向在0-360度范围内
    while (g_simulation_data.wind_direction < 0.0f) g_simulation_data.wind_direction += 360.0f;
    while (g_simulation_data.wind_direction >= 360.0f) g_simulation_data.wind_direction -= 360.0f;
}

/**
 * @brief 更新模拟覆冰厚度
 * 
 * 根据当前环境条件和季节阶段，平滑更新覆冰厚度
 */
void update_simulation_ice_thickness(void) {
    // 保存上一次厚度用于状态判断
    g_prev_ice_thickness = g_simulation_data.equivalent_ice_thickness;
    
    // 非冬季或处于无覆冰阶段，逐渐减少覆冰到0
    if (g_simulation_data.current_season != SEASON_WINTER || 
        g_simulation_data.ice_phase == ICE_PHASE_NONE_START || 
        g_simulation_data.ice_phase == ICE_PHASE_NONE_END) {
        
        // 覆冰缓慢减少，根据温度调整减少速率，降低变化率以避免突变
        float melt_rate = 0.01f;  // 进一步降低基础融化率为1%，原为1.5%
        
        // 根据温度调整融化速率，降低变化率
        if (g_simulation_data.temperature > 10.0f) {
            // 高温加速融化，但降低加速幅度
            melt_rate = 0.02f;  // 降低为2%，原为3%
        } else if (g_simulation_data.temperature > 5.0f) {
            // 温和加速融化
            melt_rate = 0.015f;  // 降低为1.5%，原为2%
        }
        
        if (g_simulation_data.equivalent_ice_thickness > 0.1f) {
            // 如果当前厚度变化率超过阈值，则限制变化幅度，避免突变
            float new_thickness = g_simulation_data.equivalent_ice_thickness * (1.0f - melt_rate);
            float thickness_change = fabs(new_thickness - g_simulation_data.equivalent_ice_thickness);
            
            // 限制最大变化率，避免数据融合系统检测到异常
            if (thickness_change > MAX_THICKNESS_CHANGE) {
                float change_dir = (new_thickness < g_simulation_data.equivalent_ice_thickness) ? -1.0f : 1.0f;
                new_thickness = g_simulation_data.equivalent_ice_thickness + change_dir * MAX_THICKNESS_CHANGE;
            }
            
            g_simulation_data.equivalent_ice_thickness = new_thickness;
        } else {
            g_simulation_data.equivalent_ice_thickness = 0.0f;
        }
    } 
    // 冬季覆冰阶段，根据目标厚度平滑变化
    else {
        float current = g_simulation_data.equivalent_ice_thickness;
        float target = g_simulation_data.target_ice_thickness;
        
        // 限制目标厚度不超过安全阈值，避免触发数据融合的警告
        const float SAFE_MAX_THICKNESS = 45.0f; // 比最大阈值50mm小一些，留出余量
        if (target > SAFE_MAX_THICKNESS) {
            target = SAFE_MAX_THICKNESS;
            g_simulation_data.target_ice_thickness = target; // 更新目标厚度
            log_message(LOG_LEVEL_INFO, "目标覆冰厚度已被限制为%.1fmm以保持数据一致性", SAFE_MAX_THICKNESS);
        }
        
        // 确保目标厚度不为负值
        if (target < 0.0f) target = 0.0f;
        
        // 计算当前与目标的差距
        float diff = target - current;
        
        // 根据差距大小和当前阶段决定变化速度
        float change_rate = 0.0f;
        
        if (g_simulation_data.ice_phase == ICE_PHASE_GROWTH) {
            // 增长阶段，增长速度与环境条件相关
            if (diff > 0) {
                float growth = calculate_ice_growth_rate(g_simulation_data.temperature, 
                                                       g_simulation_data.humidity, 
                                                       g_simulation_data.wind_speed);
                
                // 考虑接近目标时减缓增长速度，使曲线更自然
                float approach_factor = 1.0f;
                if (current > 0.7f * target && target > 0.0f) {
                    // 当达到目标的70%时，开始减缓增长速度
                    approach_factor = 1.0f - (current - 0.7f * target) / (0.3f * target);
                    if (approach_factor < 0.5f) approach_factor = 0.5f;
                }
                
                change_rate = growth * approach_factor;
                
                // 限制变化率，避免异常波动
                if (change_rate > MAX_THICKNESS_CHANGE) {
                    change_rate = MAX_THICKNESS_CHANGE;
                }
            } else {
                // 已达到目标，小幅波动，进一步减小波动幅度
                change_rate = ((float)rand() / RAND_MAX * 0.06f - 0.03f); // 减小波动幅度到±0.03
            }
        } 
        else if (g_simulation_data.ice_phase == ICE_PHASE_STABLE) {
            // 稳定阶段，小幅波动但趋向于目标值，减小变化率
            change_rate = diff * 0.01f + ((float)rand() / RAND_MAX * 0.04f - 0.02f); // 进一步减小波动幅度
            
            // 限制变化幅度
            if (change_rate > 0.15f) change_rate = 0.15f;
            if (change_rate < -0.15f) change_rate = -0.15f;
            
            // 环境条件的额外影响，减小环境影响
            if (g_simulation_data.temperature < -15.0f && g_simulation_data.humidity > 85.0f) {
                // 极低温高湿条件下，仍有小幅增长，但减小影响
                change_rate += 0.02f; // 降低为0.02，原为0.03
            } else if (g_simulation_data.temperature > -1.0f) {
                // 接近零度时，可能轻微融化，但减小影响
                change_rate -= 0.01f; // 降低为0.01，原为0.02
            }
        }
        else if (g_simulation_data.ice_phase == ICE_PHASE_REDUCTION) {
            // 减少阶段，减少速度与温度相关
            if (diff < 0) {
                // 基础融化率，与温度正相关，降低基础值
                float melt_base = 0.02f; // 降低为0.02，原为0.03
                float temp_factor = (g_simulation_data.temperature + 5.0f) * 0.01f; // 降低为0.01，原为0.02
                if (temp_factor < 0) temp_factor = 0;
                
                float melt_rate = melt_base + temp_factor;
                
                // 湿度对融化的影响 - 降低影响因子
                if (g_simulation_data.humidity < 60.0f) {
                    melt_rate *= 1.03f; // 降低为1.03，原为1.05
                }
                
                // 风速对融化的影响 - 降低影响因子
                if (g_simulation_data.wind_speed > 8.0f) {
                    melt_rate *= 1.03f; // 降低为1.03，原为1.05
                }
                
                change_rate = -melt_rate;
                
                // 考虑接近目标时减缓融化速度
                if (current < target * 1.5f && target > 0.0f) {
                    change_rate *= (current - target) / (target * 0.5f);
                }
                
                // 限制变化率，避免突变
                if (change_rate < -MAX_THICKNESS_CHANGE) {
                    change_rate = -MAX_THICKNESS_CHANGE;
                }
                
                // 确保变化率不会导致负值
                if (current + change_rate < 0.0f) {
                    change_rate = -current;
                }
            } else {
                // 已低于目标，小幅波动，减小波动幅度
                change_rate = ((float)rand() / RAND_MAX * 0.04f - 0.02f); // 减小波动幅度
                
                // 确保不会导致负值
                if (current + change_rate < 0.0f) {
                    change_rate = 0.0f;
                }
            }
        }
        
        // 平滑变化处理：如果变化太大，则进行限制
        float abs_change = fabs(change_rate);
        if (abs_change > MAX_THICKNESS_CHANGE) {
            change_rate = (change_rate > 0) ? MAX_THICKNESS_CHANGE : -MAX_THICKNESS_CHANGE;
        }
        
        // 应用变化率，更新覆冰厚度
        g_simulation_data.equivalent_ice_thickness += change_rate;
        
        // 确保不为负值
        if (g_simulation_data.equivalent_ice_thickness < 0.0f) {
            g_simulation_data.equivalent_ice_thickness = 0.0f;
        }
        
        // 上限控制，避免超过合理的最大值
        if (g_simulation_data.equivalent_ice_thickness > MAX_ICE_THICKNESS) {
            g_simulation_data.equivalent_ice_thickness = MAX_ICE_THICKNESS;
        }
    }
    
    // 更新真实线缆覆冰厚度，与等值线缆厚度保持一致但有轻微差异
    // 减小随机误差范围，避免数据融合检测到异常
    float bias_base = ((float)rand() / RAND_MAX * 0.1f - 0.05f);  // 进一步降低基础误差范围为±0.05，原为±0.1
    
    // 在高风速或极端温度下增加误差，但减小影响系数
    if (g_simulation_data.wind_speed > 12.0f || 
        g_simulation_data.temperature < -20.0f || 
        g_simulation_data.temperature > 5.0f) {
        bias_base *= 1.1f; // 降低为1.1，原为1.15
    }
    
    // 厚度越大，绝对误差可能越大，但减小系数
    float thickness_factor = 1.0f;
    if (g_simulation_data.equivalent_ice_thickness > 0.0f) {
        thickness_factor = 1.0f + g_simulation_data.equivalent_ice_thickness / 50.0f * 0.2f; // 降低为0.2，原为0.3
    }
    float bias = bias_base * thickness_factor;
    
    // 确保bias不会导致负值
    if (g_simulation_data.equivalent_ice_thickness + bias < 0.0f) {
        bias = 0.0f;
    }
    
    // 确保偏差不会太大，避免触发异常检测
    float max_allowed_bias = 0.5f; // 降低最大允许偏差，原为0.8
    if (fabs(bias) > max_allowed_bias) {
        bias = (bias > 0) ? max_allowed_bias : -max_allowed_bias;
    }
    
    g_simulation_data.real_ice_thickness = g_simulation_data.equivalent_ice_thickness + bias;
    
    // 确保真实线缆覆冰厚度不为负
    if (g_simulation_data.real_ice_thickness < 0.0f) {
        g_simulation_data.real_ice_thickness = 0.0f;
    }
    
    // 确保真实厚度不超过最大安全值
    if (g_simulation_data.real_ice_thickness > MAX_ICE_THICKNESS) {
        g_simulation_data.real_ice_thickness = MAX_ICE_THICKNESS;
    }
}

/**
 * @brief 计算覆冰生长率
 * @param temperature 环境温度(°C)
 * @param humidity 相对湿度(%)
 * @param wind_speed 风速(m/s)
 * @return float 每次更新增加的覆冰厚度(mm)
 */
float calculate_ice_growth_rate(float temperature, float humidity, float wind_speed) {
    // 基础覆冰生长率
    float base_rate = 0.05f;
    
    // 温度影响因子 - 温度越低，覆冰越快
    float temp_factor = 1.0f;
    if (temperature < -20.0f) {
        temp_factor = 3.0f;  // 极低温条件下，覆冰生长更快
    } else if (temperature < -10.0f) {
        temp_factor = 2.0f;  // 低温条件下覆冰增长加速
    } else if (temperature < -5.0f) {
        temp_factor = 1.5f;  // 轻微低温条件
    } else if (temperature < 0.0f) {
        temp_factor = 1.0f;  // 温度接近0°C，正常增长
    } else {
        // 温度高于0°C，覆冰不增长甚至融化
        // 修改：确保返回值不会太小，避免产生负增长
        return 0.0f;  // 高于零度时，不增长但也不一定减少
    }
    
    // 湿度影响因子 - 湿度越高，覆冰越快
    float humidity_factor = 1.0f;
    if (humidity > 90.0f) {
        humidity_factor = 1.5f;  // 极高湿度条件
    } else if (humidity > 80.0f) {
        humidity_factor = 1.2f;  // 高湿度条件
    } else if (humidity > 70.0f) {
        humidity_factor = 1.0f;  // 中等湿度
    } else {
        humidity_factor = 0.8f;  // 低湿度条件
    }
    
    // 风速影响因子 - 风速在一定范围内促进覆冰
    float wind_factor = 1.0f;
    if (wind_speed > 15.0f) {
        wind_factor = 0.8f;  // 风速过高可能减缓覆冰
    } else if (wind_speed > 10.0f) {
        wind_factor = 1.2f;  // 相对高风速促进覆冰
    } else if (wind_speed > 5.0f) {
        wind_factor = 1.5f;  // 适中风速最有利于覆冰形成
    } else {
        wind_factor = 1.0f;  // 低风速
    }
    
    // 计算最终生长率
    float growth_rate = base_rate * temp_factor * humidity_factor * wind_factor;
    
    // 确保增长率不小于一个最小值，避免数据异常
    if (growth_rate < 0.01f) {
        growth_rate = 0.01f;
    }
    
    return growth_rate;
}

/**
 * @brief 获取模拟传感器数据
 * 
 * 根据当前模拟状态填充传感器数据结构
 * 
 * @param data 传感器数据指针
 */
void get_simulation_sensor_data(SensorData *data) {
    if (data == NULL) {
        return;
    }
    
    // 填充基本环境数据
    data->temperature = g_simulation_data.temperature;
    data->humidity = g_simulation_data.humidity;
    data->wind_speed = g_simulation_data.wind_speed;
    data->wind_direction = g_simulation_data.wind_direction;
    
    // 根据覆冰厚度计算拉力值 - 严格确保非负厚度
    float ice_thickness = g_simulation_data.equivalent_ice_thickness;
    if (ice_thickness < 0.0f) {
        ice_thickness = 0.0f;  // 确保厚度非负
    }
    
    float ice_density = calculate_ice_density(data->temperature, data->humidity);
    float base_tension = 1000.0f;  // 基础拉力，无覆冰时的拉力
    
    // 每毫米覆冰增加的拉力，根据密度调整，但降低变化幅度
    float tension_per_mm = 7.0f * (ice_density / 600.0f);  // 降低为7.0，更平稳
    
    // 计算覆冰造成的额外拉力 - 平滑处理
    float ice_tension = ice_thickness * tension_per_mm;
    
    // 加入风力影响，但降低影响幅度
    float wind_tension = data->wind_speed * data->wind_speed * 0.3f;  // 降低系数
    
    // 计算总拉力，并降低随机波动
    float total_tension = base_tension;
    
    // 只有当有覆冰时才增加拉力
    if (ice_thickness > 0.0f) {
        total_tension += ice_tension + wind_tension;
    } else {
        // 无覆冰时，只有风力和小的随机波动影响
        total_tension += wind_tension * 0.5f;  // 降低无冰时风力影响
    }
    
    // 确保拉力值合理
    if (total_tension < base_tension) {
        total_tension = base_tension;
    }
    
    // 添加两个传感器间的极小随机差异
    float random_factor1 = 1.0f + ((float)rand() / RAND_MAX * 0.02f - 0.01f);  // 降低为±1%随机波动
    float random_factor2 = 1.0f + ((float)rand() / RAND_MAX * 0.02f - 0.01f);  // 降低为±1%随机波动
    
    // 计算新的拉力值
    float new_tension1 = total_tension * random_factor1;
    float new_tension2 = total_tension * random_factor2;
    
    // 确保新的拉力值与前一次的拉力值变化不会太大
    // 平滑过渡到新的拉力值
    if (g_prev_tension1 > 0.1f) {  // 避免首次运行时问题
        float tension_change1 = new_tension1 - g_prev_tension1;
        if (fabs(tension_change1) > MAX_TENSION_CHANGE) {
            float change_dir = (tension_change1 > 0) ? 1.0f : -1.0f;
            new_tension1 = g_prev_tension1 + change_dir * MAX_TENSION_CHANGE;
        }
    }
    
    if (g_prev_tension2 > 0.1f) {  // 避免首次运行时问题
        float tension_change2 = new_tension2 - g_prev_tension2;
        if (fabs(tension_change2) > MAX_TENSION_CHANGE) {
            float change_dir = (tension_change2 > 0) ? 1.0f : -1.0f;
            new_tension2 = g_prev_tension2 + change_dir * MAX_TENSION_CHANGE;
        }
    }
    
    // 确保两个传感器之间的差异不会太大
    float tension_diff = fabs(new_tension1 - new_tension2);
    if (tension_diff > 3.0f) {  // 限制最大差异为3N
        // 调整两个值向彼此靠拢
        float avg = (new_tension1 + new_tension2) / 2.0f;
        new_tension1 = avg + (new_tension1 > new_tension2 ? 1.5f : -1.5f);
        new_tension2 = avg + (new_tension2 > new_tension1 ? 1.5f : -1.5f);
    }
    
    data->tension1 = new_tension1;
    data->tension2 = new_tension2;
    
    // 更新前一次的拉力值
    g_prev_tension1 = data->tension1;
    g_prev_tension2 = data->tension2;
    
    // 设置其他传感器数据 - 降低波动
    data->battery_level = 90.0f - ((float)rand() / RAND_MAX * 5.0f);  // 85-90%之间
    data->voltage = 11.8f + ((float)rand() / RAND_MAX * 0.5f);        // 11.8-12.3V之间
}

/**
 * @brief 调整模拟数据
 * 
 * 根据运行模式和冰密度调整模拟数据
 * 
 * @param run_mode 运行模式
 * @param ice_density 冰密度
 */
void adjust_simulation_data(RunMode run_mode, float ice_density) {
    // 根据运行模式调整模拟数据
    switch (run_mode) {
        case RUN_MODE_SENSOR_ONLY: 
            // 仅传感器模式时稍微增加波动性
            if (((float)rand() / RAND_MAX) > 0.9f) {
                // 偶尔有明显波动
                g_simulation_data.temperature += ((float)rand() / RAND_MAX) * 1.0f - 0.5f;
                g_simulation_data.wind_speed += ((float)rand() / RAND_MAX) * 2.0f - 1.0f;
            }
            break;
            
        case RUN_MODE_SENSOR_VISUAL:
            // 传感器+视觉模式时偶尔模拟传感器和视觉数据不一致的情况
            if (((float)rand() / RAND_MAX) > 0.8f) {
                float visual_bias = ((float)rand() / RAND_MAX) * 2.0f - 1.0f;
                g_simulation_data.real_ice_thickness = g_simulation_data.equivalent_ice_thickness + visual_bias;
                if (g_simulation_data.real_ice_thickness < 0.0f) g_simulation_data.real_ice_thickness = 0.0f;
            }
            break;
            
        case RUN_MODE_STEREO_CAMERA:
            // 立体视觉模式时，模拟更准确的冰厚度测量
            if (((float)rand() / RAND_MAX) > 0.9f) {
                float stereo_bias = ((float)rand() / RAND_MAX) * 0.4f - 0.2f;
                g_simulation_data.real_ice_thickness = g_simulation_data.equivalent_ice_thickness + stereo_bias;
                if (g_simulation_data.real_ice_thickness < 0.0f) g_simulation_data.real_ice_thickness = 0.0f;
            }
            break;
            
        case RUN_MODE_FULL_SYSTEM:
            // 完整系统模式下，模拟系统的自我修正能力
            if (((float)rand() / RAND_MAX) > 0.95f) {
                // (较低概率)模拟传感器数据抖动
                g_simulation_data.equivalent_tension *= 1.0f + ((float)rand() / RAND_MAX) * 0.3f - 0.15f;
            }
            break;
            
        case RUN_MODE_SIMULATION:
            // 纯模拟模式，增加一些有趣的变化
            if (g_simulation_data.simulation_phase == 1 && g_simulation_data.phase_counter > 20) {
                // 覆冰增长阶段中期，偶尔模拟急速增加
                if (((float)rand() / RAND_MAX) > 0.9f) {
                    g_simulation_data.equivalent_ice_thickness *= 1.0f + ((float)rand() / RAND_MAX) * 0.2f;
                    log_message(LOG_LEVEL_DEBUG, "模拟覆冰急速增长: %.2f mm", g_simulation_data.equivalent_ice_thickness);
                }
            }
            else if (g_simulation_data.simulation_phase == 3 && g_simulation_data.phase_counter > 15) {
                // 覆冰减少阶段，偶尔模拟急速融化
                if (((float)rand() / RAND_MAX) > 0.9f) {
                    g_simulation_data.equivalent_ice_thickness *= 0.8f;
                    log_message(LOG_LEVEL_DEBUG, "模拟覆冰急速融化: %.2f mm", g_simulation_data.equivalent_ice_thickness);
                }
            }
            break;
            
        default:
            break;
    }
    
    // 根据冰密度调整覆冰数据
    if (ice_density < 500.0f) {
        // 低密度冰(霜)，覆冰厚度稍大，但重量轻
        g_simulation_data.real_ice_thickness *= 1.1f;
    } else if (ice_density > 800.0f) {
        // 高密度冰(雨凇)，覆冰厚度稍小，但重量大
        g_simulation_data.real_ice_thickness *= 0.9f;
    }
}

/**
 * @brief 模拟采集视觉数据
 * 
 * @param thickness 输出的冰厚度指针
 * @return int 成功返回1，失败返回0
 */
int simulate_visual_data(float *thickness) {
    if (thickness == NULL) {
        return 0;
    }
    
    // 模拟视觉测量的延迟和随机误差
    usleep(50000);  // 模拟处理延迟50ms
    
    // 基于当前模拟厚度，加入测量误差，但保持与等值线缆厚度的趋势一致
    float base_thickness = g_simulation_data.equivalent_ice_thickness;
    
    // 确保基础厚度非负
    if (base_thickness < 0.0f) {
        base_thickness = 0.0f;
    }
    
    // 进一步减小误差范围，防止产生负值并避免异常检测
    float error_range = 0.2f;  // 降低为0.2，原为0.3
    if (base_thickness < 1.0f) {
        // 当基础厚度很小时，更进一步减小误差范围，避免负值
        error_range = base_thickness * 0.15f;  // 降低为0.15，原为0.2
    }
    
    // 限制最大误差幅度，避免触发异常检测
    float max_error = 0.3f; // 降低最大允许误差，原为0.5
    if (error_range > max_error) {
        error_range = max_error;
    }
    
    float error = ((float)rand() / RAND_MAX) * error_range - (error_range / 2.0f);
    *thickness = base_thickness + error;
    
    // 确保数值不为负
    if (*thickness < 0.0f) {
        *thickness = 0.0f;
    }
    
    // 确保不超过最大阈值
    if (*thickness > MAX_ICE_THICKNESS) {
        *thickness = MAX_ICE_THICKNESS;
    }
    
    return 1;
}

/**
 * @brief 模拟采集立体视觉数据
 * 
 * @param thickness 输出的冰厚度指针
 * @return int 成功返回1，失败返回0
 */
int simulate_stereo_data(float *thickness) {
    if (thickness == NULL) {
        return 0;
    }
    
    // 模拟立体视觉测量的延迟和更小的随机误差
    usleep(100000);  // 模拟处理延迟100ms
    
    // 立体视觉测量更准确，误差范围更小
    float base_thickness = g_simulation_data.real_ice_thickness;
    
    // 确保基础厚度非负
    if (base_thickness < 0.0f) {
        base_thickness = 0.0f;
    }
    
    // 进一步减小误差范围，防止产生负值
    float error_range = 0.15f;  // 降低为0.15，原为0.2
    if (base_thickness < 0.5f) {
        // 当基础厚度很小时，减小误差范围，避免负值
        error_range = base_thickness * 0.1f;  // 降低为0.1，原为0.15
    }
    
    // 限制最大误差幅度，避免触发数据异常
    float max_error = 0.2f; // 降低最大允许误差，原为0.3
    if (error_range > max_error) {
        error_range = max_error;
    }
    
    float error = ((float)rand() / RAND_MAX) * error_range - (error_range / 2.0f);
    
    // 确保与视觉数据的一致性，避免过大差异触发警告
    // 如果上一次生成了视觉数据，确保立体视觉数据与之相差不会太大
    static float last_visual_thickness = 0.0f;
    static uint64_t last_visual_time = 0;
    uint64_t current_time = get_timestamp_ms();
    
    // 如果有最近的视觉数据，考虑与之保持一致
    if (current_time - last_visual_time < 5000) { // 5秒内的视觉数据被认为是最新的
        // 计算与视觉测量的最大允许偏差
        float max_allowed_diff = 0.8f; // 降低最大允许差异，原为1.0
        float raw_thickness = base_thickness + error;
        
        // 如果与视觉测量差异太大，则调整立体视觉结果
        if (fabs(raw_thickness - last_visual_thickness) > max_allowed_diff) {
            // 向视觉测量结果靠拢，但保持一定的差异
            float diff_direction = (raw_thickness > last_visual_thickness) ? 1.0f : -1.0f;
            *thickness = last_visual_thickness + diff_direction * ((float)rand() / RAND_MAX) * max_allowed_diff * 0.8f;
        } else {
            *thickness = raw_thickness;
        }
    } else {
        // 没有最近的视觉数据，使用正常计算结果
        *thickness = base_thickness + error;
        
        // 存储当前厚度，用于下次视觉数据一致性检查
        last_visual_thickness = *thickness;
        last_visual_time = current_time;
    }
    
    // 确保数值不为负
    if (*thickness < 0.0f) {
        *thickness = 0.0f;
    }
    
    // 确保不超过最大阈值
    if (*thickness > MAX_ICE_THICKNESS) {
        *thickness = MAX_ICE_THICKNESS;
    }
    
    return 1;
}

/**
 * @brief 根据传感器和视觉数据计算运行时冰厚度
 * 
 * @param sensor_thickness 传感器测量厚度
 * @param visual_thickness 视觉测量厚度
 * @param use_correction 是否使用修正
 * @return float 计算的冰厚度
 */
float calculate_runtime_ice_thickness(float sensor_thickness, float visual_thickness, bool use_correction) {
    // 确保输入数据非负
    if (sensor_thickness < 0.0f) sensor_thickness = 0.0f;
    if (visual_thickness < 0.0f) visual_thickness = 0.0f;
    
    // 基础权重设置
    float sensor_weight = 0.7f;    // 传感器权重基准值
    float visual_weight = 0.3f;    // 视觉权重基准值
    
    // 在低温下提高传感器权重，高温下降低传感器权重
    if (g_simulation_data.temperature < 0.0f) {
        // 温度越低，传感器权重越高，但最高不超过0.85
        sensor_weight += (0.0f - g_simulation_data.temperature) / 20.0f;
        if (sensor_weight > 0.85f) {
            sensor_weight = 0.85f;
        }
    } else {
        // 温度越高，传感器权重越低，但最低不低于0.4
        sensor_weight -= g_simulation_data.temperature / 30.0f;
        if (sensor_weight < 0.4f) {
            sensor_weight = 0.4f;
        }
    }
    
    // 使用修正选项调整权重
    if (use_correction) {
        // 如果需要修正，增加视觉测量的权重
        visual_weight = 1.0f - sensor_weight;
    } else {
        // 默认权重
        visual_weight = 1.0f - sensor_weight;
    }
    
    // 测量值差异较大时，调整权重
    float diff = fabs(sensor_thickness - visual_thickness);
    float avg = (sensor_thickness + visual_thickness) / 2.0f;
    float diff_percent = (avg > 0.1f) ? (diff / avg) : 0.0f;
    
    if (diff_percent > 0.3f) {
        // 差异较大时，更倾向于相信传感器数据
        sensor_weight += 0.15f;
        if (sensor_weight > 0.9f) sensor_weight = 0.9f;
        visual_weight = 1.0f - sensor_weight;
    }
    
    // 融合测量结果
    float result = sensor_thickness * sensor_weight + visual_thickness * visual_weight;
    
    // 确保结果非负
    if (result < 0.0f) {
        result = 0.0f;
    }
    
    return result;
}

/**
 * @brief 将模拟传感器数据转换为传感器数据包
 * 
 * @param data 输出的传感器数据包指针
 */
void convert_simulation_sensor_data(SensorDataPacket *data) {
    if (!data) {
        return;
    }
    
    // 更新模拟数据
    update_simulation_environment();
    update_simulation_ice_thickness();
    
    // 计算冰密度 - 基于温度和湿度
    float ice_density = calculate_ice_density(g_simulation_data.temperature, g_simulation_data.humidity);
    
    // 调整模拟数据以匹配当前运行模式
    adjust_simulation_data(get_current_run_mode(), ice_density);
    
    // 生成一个随机传感器数据
    generate_random_sensor_data();
    
    // 获取模拟的传感器数据
    const SensorMockData *mock_data = get_sensor_mock_data();
    
    // 填充数据包
    data->temperature = mock_data->temperature;
    data->humidity = mock_data->humidity;
    data->wind_speed = mock_data->wind_speed;
    data->wind_direction = mock_data->wind_direction;
    
    // 修改：确保拉力值在合理的正值范围内，并且与线缆覆冰厚度一致
    // 无覆冰情况下的基础拉力值
    float base_tension = 1000.0f;
    // 每毫米覆冰增加的拉力
    float tension_per_mm = 10.0f;
    // 基于当前覆冰厚度计算拉力
    float ice_tension = g_simulation_data.equivalent_ice_thickness * tension_per_mm;
    // 添加风力带来的额外拉力
    float wind_tension = data->wind_speed * data->wind_speed * 0.2f;
    // 计算总拉力
    float total_tension = base_tension + ice_tension + wind_tension;
    
    // 两个传感器的拉力值应该相近但有微小差异
    // 使用较小的随机差异，在±1%范围内
    float variation1 = ((float)rand() / RAND_MAX * 2.0f - 1.0f) * 0.01f;
    float variation2 = ((float)rand() / RAND_MAX * 2.0f - 1.0f) * 0.01f;
    
    data->tension1 = total_tension * (1.0f + variation1);
    data->tension2 = total_tension * (1.0f + variation2);
    
    // 确保拉力值不小于基础拉力的90%
    if (data->tension1 < base_tension * 0.9f) {
        data->tension1 = base_tension * 0.9f;
    }
    if (data->tension2 < base_tension * 0.9f) {
        data->tension2 = base_tension * 0.9f;
    }
    
    // 其他传感器参数
    data->battery_level = mock_data->battery_level;
    data->voltage = mock_data->voltage;
    data->signal_strength = mock_data->signal_strength;
    
    // 添加当前时间戳
    data->timestamp = get_timestamp_ms();
}

/**
 * @brief 填充模拟的立体视觉数据
 * 
 * @param data 输出的立体视觉数据指针
 * @param cable_diameter 线缆直径(mm)
 * @param current_time 当前时间戳
 * @return bool 成功返回true，失败返回false
 */
bool convert_simulation_stereo_data(StereoData *data, float cable_diameter, uint64_t current_time) {
    if (!data) {
        return false;
    }
    
    // 更新季节和覆冰状态
    update_season_cycle(current_time);
    
    // 获取季节视觉特征，影响测量准确度
    float brightness, contrast, scene_color, fog_density, visible_range;
    get_season_visual_features(&brightness, &contrast, &scene_color, &fog_density, &visible_range);
    
    // 基于季节视觉特征调整误差
    float error_base = ((float)rand() / RAND_MAX * 0.5f);  // 基础误差改为只有正向误差
    
    // 基于季节视觉特征调整误差
    float season_error_factor = 0.5f;  // 减小基础误差因子
    
    // 可见度越低，测量误差越大
    season_error_factor *= (2.0f - visible_range);
    
    // 雾气密度越高，测量误差越大
    season_error_factor *= (1.0f + fog_density);
    
    // 亮度太高或太低都会增加误差
    float brightness_error = fabs(brightness - 1.0f) * 0.5f;
    season_error_factor *= (1.0f + brightness_error);
    
    // 计算最终误差
    float error = error_base * season_error_factor;
    
    // 应用厚度
    data->thickness = g_simulation_data.real_ice_thickness;
    
    // 只有在实际有覆冰时才考虑测量误差
    if (data->thickness > 0.1f) {
        // 添加正向误差
        data->thickness += error;
    } else {
        // 无覆冰或极微量覆冰时，视觉厚度为0
        data->thickness = 0.0f;
    }
    
    // 设置视差和距离 - 基于覆冰厚度计算
    float distance_base = 10.0f;  // 基础距离，单位米
    float distance_range = 0.5f;  // 距离波动范围，单位米
    
    float disparity_base = 150.0f;  // 基础视差
    float disparity_range = 10.0f;  // 视差波动范围
    
    // 根据覆冰厚度调整视差和距离参数，模拟视觉测量效果
    distance_base -= data->thickness * 0.02f;  // 覆冰厚度越大，测量距离会略微减小
    
    // 添加随机波动
    data->distance = distance_base + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * distance_range;
    data->disparity = disparity_base + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * disparity_range;
    
    // 确保距离合理
    if (data->distance < 5.0f) data->distance = 5.0f;
    if (data->distance > 15.0f) data->distance = 15.0f;
    
    // 确保视差合理
    if (data->disparity < 100.0f) data->disparity = 100.0f;
    if (data->disparity > 200.0f) data->disparity = 200.0f;
    
    data->cable_diameter = cable_diameter;
    data->timestamp = current_time;
    
    // 计算覆冰体积
    if (data->thickness > 0.0f) {
        // 每毫米长度的冰体积，单位立方毫米/毫米
        data->volume = M_PI * (
            pow(cable_diameter/2.0f + data->thickness, 2) - 
            pow(cable_diameter/2.0f, 2)
        );
    } else {
        data->volume = 0.0f;
    }
    
    // 新增：设置季节和视觉条件信息
    data->measurement_conditions = (uint8_t)(g_simulation_data.current_season) | 
                                ((uint8_t)(g_simulation_data.ice_phase) << 4);
    
    // 视觉条件质量 - 季节特征的综合评分(0-100)
    uint8_t visual_quality = (uint8_t)(visible_range * 50.0f + (1.0f - fog_density) * 30.0f + 
                                     (brightness > 0.7f && brightness < 1.3f ? 20.0f : 0.0f));
    data->visual_quality = visual_quality;
    
    // 创建模拟的左右摄像头图像帧数据（800W摄像头，3840x2160 RGB图像）
    int width = 3840;
    int height = 2160;
    int channels = 3; // RGB
    size_t image_size = width * height * channels;
    
    // 左相机图像处理
    if (data->left_frame.data) {
        free(data->left_frame.data);
        data->left_frame.data = NULL;
    }
    
    data->left_frame.data = (unsigned char*)malloc(image_size);
    if (!data->left_frame.data) {
        log_message(LOG_LEVEL_ERROR, "无法为左相机模拟图像分配内存");
        return false;
    }
    
    data->left_frame.width = width;
    data->left_frame.height = height;
    data->left_frame.channels = channels;
    data->left_frame.size = image_size;
    
    // 填充左相机图像数据（灰色背景）
    memset(data->left_frame.data, 128, image_size);
    
    // 右相机图像处理
    if (data->right_frame.data) {
        free(data->right_frame.data);
        data->right_frame.data = NULL;
    }
    
    data->right_frame.data = (unsigned char*)malloc(image_size);
    if (!data->right_frame.data) {
        // 释放左相机数据以避免内存泄漏
        free(data->left_frame.data);
        data->left_frame.data = NULL;
        log_message(LOG_LEVEL_ERROR, "无法为右相机模拟图像分配内存");
        return false;
    }
    
    data->right_frame.width = width;
    data->right_frame.height = height;
    data->right_frame.channels = channels;
    data->right_frame.size = image_size;
    
    // 填充右相机图像数据（略微不同的灰色背景，模拟视差）
    memset(data->right_frame.data, 136, image_size);
    
    return true;
}

/**
 * @brief 填充模拟的视觉数据
 * 
 * @param data 输出的视觉数据指针
 * @param cable_diameter 线缆直径(mm)
 * @param current_time 当前时间戳
 * @return bool 成功返回true，失败返回false
 */
bool convert_simulation_visual_data(VisualIceData *data, float cable_diameter, uint64_t current_time) {
    if (!data) {
        return false;
    }
    
    // 更新季节和覆冰状态
    update_season_cycle(current_time);
    
    // 获取季节视觉特征
    float brightness, contrast, scene_color, fog_density, visible_range;
    get_season_visual_features(&brightness, &contrast, &scene_color, &fog_density, &visible_range);
    
    // 基于季节视觉特征计算误差
    float error_base = ((float)rand() / RAND_MAX * 0.4f);  // 基础误差修改为只有正向误差
    
    // 可见度、雾气和亮度对测量精度的影响
    float season_error_factor = 0.5f;  // 减小基础误差因子
    season_error_factor *= (2.0f - visible_range);
    season_error_factor *= (1.0f + fog_density);
    
    float brightness_error = fabs(brightness - 1.0f) * 0.5f;
    season_error_factor *= (1.0f + brightness_error);
    
    // 最终误差 - 确保是正值或接近零的值
    float error = error_base * season_error_factor;
    
    // 应用厚度
    data->thickness = g_simulation_data.equivalent_ice_thickness;
    
    // 只有在实际有覆冰时才考虑测量误差
    if (data->thickness > 0.1f) {
        // 添加正向误差
        data->thickness += error;
    } else {
        // 无覆冰或极微量覆冰时，视觉厚度更稳定
        data->thickness = 0.0f;
    }
    
    // 计算覆冰率 - 根据覆冰厚度和季节阶段
    float coverage_base = 0.0f;
    
    if (g_simulation_data.equivalent_ice_thickness <= 0.1f) {
        // 无覆冰或极微量
        coverage_base = 0.0f;
    } else if (g_simulation_data.equivalent_ice_thickness < 5.0f) {
        // 微量覆冰
        coverage_base = 20.0f + g_simulation_data.equivalent_ice_thickness * 8.0f;
    } else if (g_simulation_data.equivalent_ice_thickness < 15.0f) {
        // 轻度覆冰
        coverage_base = 60.0f + (g_simulation_data.equivalent_ice_thickness - 5.0f) * 2.0f;
    } else if (g_simulation_data.equivalent_ice_thickness < 30.0f) {
        // 中度覆冰
        coverage_base = 80.0f + (g_simulation_data.equivalent_ice_thickness - 15.0f) * 1.0f;
    } else {
        // 重度覆冰
        coverage_base = 95.0f;
    }
    
    // 添加季节和阶段影响
    if (g_simulation_data.current_season == SEASON_WINTER) {
        if (g_simulation_data.ice_phase == ICE_PHASE_GROWTH) {
            coverage_base -= 5.0f; // 生长阶段覆盖不够均匀
        } else if (g_simulation_data.ice_phase == ICE_PHASE_REDUCTION) {
            coverage_base -= 10.0f; // 减少阶段更不均匀
        }
    }
    
    // 添加视觉条件影响
    // 雾气会影响覆冰表面均匀性的视觉观察
    coverage_base -= fog_density * 15.0f;
    
    // 可见度越低，覆冰率观察越不准确
    float visibility_error = (1.0f - visible_range) * 10.0f;
    
    // 添加随机波动
    float coverage_variation = ((float)rand() / RAND_MAX * 10.0f - 5.0f) + visibility_error;
    data->coverage_rate = coverage_base + coverage_variation;
    
    // 限制覆盖率范围
    if (data->coverage_rate < 0.0f) data->coverage_rate = 0.0f;
    if (data->coverage_rate > 100.0f) data->coverage_rate = 100.0f;
    
    // 设置其他参数
    data->cable_diameter = cable_diameter;
    data->timestamp = current_time;
    
    // 设置季节和视觉质量信息
    data->season_info = (uint8_t)g_simulation_data.current_season;
    
    // 基于季节特征计算图像质量(0-100)
    uint8_t image_quality = (uint8_t)(visible_range * 50.0f + (1.0f - fog_density) * 30.0f + 
                                    (brightness > 0.7f && brightness < 1.3f ? 20.0f : 0.0f));
    data->image_quality = image_quality;
    
    // 设置亮度和对比度信息，用于后续显示和处理
    data->brightness_factor = brightness;
    data->contrast_factor = contrast;
    
    // 创建模拟图像帧数据（400W摄像头，2560x1440 RGB图像）
    int width = 2560;
    int height = 1440;
    int channels = 3; // RGB
    size_t image_size = width * height * channels;
    
    // 如果之前有分配过内存，先释放
    if (data->latest_frame.data) {
        free(data->latest_frame.data);
        data->latest_frame.data = NULL;
    }
    
    // 分配图像内存
    data->latest_frame.data = (unsigned char*)malloc(image_size);
    if (!data->latest_frame.data) {
        log_message(LOG_LEVEL_ERROR, "无法为模拟图像分配内存");
        return false;
    }
    
    // 设置图像参数
    data->latest_frame.width = width;
    data->latest_frame.height = height;
    data->latest_frame.channels = channels;
    data->latest_frame.size = image_size;
    
    // 填充基本图像数据（灰色背景）
    memset(data->latest_frame.data, 128, image_size);
    
    // 在此处可以添加更多代码来绘制线缆和覆冰的模拟图像
    // 但这超出了当前修复的范围，我们先创建一个基本的灰色图像
    
    return true;
}

/**
 * @brief 生成随机传感器数据
 * 从uart_handler.c移植过来的函数，用于生成随机的传感器数据
 */
void generate_random_sensor_data(void) {
    // 使用时间作为随机种子
    static int seed_initialized = 0;
    if (!seed_initialized) {
        srand((unsigned int)time(NULL));
        seed_initialized = 1;
    }
    
    uint64_t current_time = get_timestamp_ms();
    
    // 首先更新季节和覆冰阶段
    update_season_cycle(current_time);
    
    // 获取当前季节的基础参数
    SeasonType season = g_simulation_data.current_season;
    const SeasonParameters* season_params = &g_season_params[season];
    
    // 如果是冬季，考虑覆冰阶段的影响
    float temp_offset = 0.0f;
    float humidity_offset = 0.0f;
    float wind_offset = 0.0f;
    
    if (season == SEASON_WINTER) {
        IcePhaseType phase = g_simulation_data.ice_phase;
        const IcePhaseParameters* phase_params = &g_ice_phase_params[phase];
        temp_offset = phase_params->temp_offset;
        humidity_offset = phase_params->humidity_offset;
        wind_offset = phase_params->wind_offset;
    }
    
    // 生成环境参数，考虑季节和阶段
    float base_temp = season_params->base_temperature + temp_offset;
    float temp_range = season_params->temp_variation;
    g_sensor_mock_data.temperature = base_temp + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * temp_range;
    
    float base_humidity = season_params->base_humidity + humidity_offset;
    float humidity_range = season_params->humidity_variation;
    g_sensor_mock_data.humidity = base_humidity + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * humidity_range;
    if (g_sensor_mock_data.humidity > 100.0f) g_sensor_mock_data.humidity = 100.0f;
    if (g_sensor_mock_data.humidity < 30.0f) g_sensor_mock_data.humidity = 30.0f;
    
    float base_wind = season_params->base_wind_speed + wind_offset;
    float wind_range = season_params->wind_variation;
    g_sensor_mock_data.wind_speed = base_wind + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * wind_range;
    if (g_sensor_mock_data.wind_speed < 0.5f) g_sensor_mock_data.wind_speed = 0.5f;
    
    // 风向随机变化
    g_sensor_mock_data.wind_direction = (float)(rand() % 360);
    
    // 使用季节和覆冰数据更新冰厚度和拉力
    if (season == SEASON_WINTER && 
        g_simulation_data.ice_phase != ICE_PHASE_NONE_START && 
        g_simulation_data.ice_phase != ICE_PHASE_NONE_END) {
        
        // 更新覆冰厚度
        update_simulation_ice_thickness();
        float ice_thickness = g_simulation_data.equivalent_ice_thickness;
        
        // 根据覆冰厚度计算拉力
        // 删除未使用的变量 - 将使用上面的冰厚度直接计算
        float base_tension = 1000.0f;  // 基础拉力
        float tension_per_mm = 10.0f;  // 每毫米覆冰增加的拉力
        float ice_tension = ice_thickness * tension_per_mm;
        float wind_tension = g_sensor_mock_data.wind_speed * g_sensor_mock_data.wind_speed * 0.2f;
        
        float total_tension = base_tension + ice_tension + wind_tension;
        
        // 添加两个传感器间的随机差异，但减小差异度
        float random_factor1 = 1.0f + ((float)rand() / RAND_MAX * 0.02f - 0.01f);  // ±1%随机波动
        float random_factor2 = 1.0f + ((float)rand() / RAND_MAX * 0.02f - 0.01f);  // ±1%随机波动
        
        g_sensor_mock_data.tension1 = total_tension * random_factor1;
        g_sensor_mock_data.tension2 = total_tension * random_factor2;
        
        // 确保拉力值不小于基础拉力的95%
        if (g_sensor_mock_data.tension1 < base_tension * 0.95f) {
            g_sensor_mock_data.tension1 = base_tension * 0.95f;
        }
        if (g_sensor_mock_data.tension2 < base_tension * 0.95f) {
            g_sensor_mock_data.tension2 = base_tension * 0.95f;
        }
    } else {
        // 非冬季或无覆冰阶段，只有基础拉力和风力
        float base_tension = 1000.0f;
        float wind_tension = g_sensor_mock_data.wind_speed * g_sensor_mock_data.wind_speed * 0.2f;
        
        float random_factor1 = 1.0f + ((float)rand() / RAND_MAX * 0.01f - 0.005f);  // ±0.5%随机波动
        float random_factor2 = 1.0f + ((float)rand() / RAND_MAX * 0.01f - 0.005f);  // ±0.5%随机波动
        
        g_sensor_mock_data.tension1 = (base_tension + wind_tension) * random_factor1;
        g_sensor_mock_data.tension2 = (base_tension + wind_tension) * random_factor2;
        
        // 确保拉力值不小于基础拉力的95%
        if (g_sensor_mock_data.tension1 < base_tension * 0.95f) {
            g_sensor_mock_data.tension1 = base_tension * 0.95f;
        }
        if (g_sensor_mock_data.tension2 < base_tension * 0.95f) {
            g_sensor_mock_data.tension2 = base_tension * 0.95f;
        }
    }
    
    // 其他传感器参数保持合理的随机值
    g_sensor_mock_data.battery_level = 90.0f - ((float)rand() / RAND_MAX * 5.0f);  // 85-90%之间随机
    g_sensor_mock_data.voltage = 23.5f + ((float)rand() / RAND_MAX * 0.5f);        // 23.5-24.0V之间随机
    g_sensor_mock_data.signal_strength = -65 - (rand() % 5);                       // -65到-70dBm之间随机
}

/**
 * @brief 获取传感器模拟数据
 * 
 * @return const SensorMockData* 传感器模拟数据指针（只读）
 */
const SensorMockData* get_sensor_mock_data(void) {
    return &g_sensor_mock_data;
}

/**
 * @brief 设置传感器模拟数据
 * 
 * @param data 传感器模拟数据指针
 */
void set_sensor_mock_data(const SensorMockData *data) {
    if (data != NULL) {
        memcpy(&g_sensor_mock_data, data, sizeof(SensorMockData));
    }
}

/**
 * @brief 设置传感器模拟模式
 * 
 * @param use_random 是否使用随机模拟数据
 */
void set_sensor_mock_mode(bool use_random) {
    g_sensor_mock_data.use_random = use_random;
}

/**
 * @brief 同步传感器随机数据与模拟环境数据
 * 
 * 将生成的随机传感器数据与模拟环境数据同步，使数据更加一致
 */
void sync_sensor_mock_with_simulation(void) {
    uint64_t current_time = get_timestamp_ms();
    
    // 首先确保季节和覆冰阶段状态是最新的
    update_season_cycle(current_time);
    
    // 添加微小随机波动使数据更自然，但保持与模拟环境接近
    // 注意：降低变化幅度以确保数据更加平滑
    float temp_variation = ((float)rand() / RAND_MAX * 0.8f - 0.4f);  // 降低温度变化幅度
    float humidity_variation = ((float)rand() / RAND_MAX * 2.0f - 1.0f);  // 降低湿度变化幅度
    float wind_speed_variation = ((float)rand() / RAND_MAX * 0.5f - 0.25f);  // 降低风速变化幅度
    float wind_dir_variation = ((float)rand() / RAND_MAX * 8.0f - 4.0f);  // 降低风向变化幅度
    
    // 采用加权平均方式同步环境数据，而不是直接加随机变化
    // 这确保了数据变化的平滑性，避免突变
    const float env_weight = 0.85f;  // 环境数据权重
    const float random_weight = 0.15f;  // 随机变化权重
    
    g_sensor_mock_data.temperature = g_simulation_data.temperature * env_weight + 
                                    (g_simulation_data.temperature + temp_variation) * random_weight;
    g_sensor_mock_data.humidity = g_simulation_data.humidity * env_weight + 
                                (g_simulation_data.humidity + humidity_variation) * random_weight;
    g_sensor_mock_data.wind_speed = g_simulation_data.wind_speed * env_weight + 
                                  (g_simulation_data.wind_speed + wind_speed_variation) * random_weight;
    g_sensor_mock_data.wind_direction = g_simulation_data.wind_direction * env_weight + 
                                      (g_simulation_data.wind_direction + wind_dir_variation) * random_weight;
    
    // 修正范围
    if (g_sensor_mock_data.humidity > 100.0f) g_sensor_mock_data.humidity = 100.0f;
    if (g_sensor_mock_data.humidity < 30.0f) g_sensor_mock_data.humidity = 30.0f;
    if (g_sensor_mock_data.wind_speed < 0.5f) g_sensor_mock_data.wind_speed = 0.5f;
    
    // 确保风向在0-360度范围内
    while (g_sensor_mock_data.wind_direction < 0.0f) 
        g_sensor_mock_data.wind_direction += 360.0f;
    while (g_sensor_mock_data.wind_direction >= 360.0f) 
        g_sensor_mock_data.wind_direction -= 360.0f;
    
    // 计算拉力 - 更精确地考虑覆冰厚度、冰密度和风力
    float ice_thickness = g_simulation_data.equivalent_ice_thickness;
    float ice_density = calculate_ice_density(g_sensor_mock_data.temperature, g_sensor_mock_data.humidity);
    float base_tension = 1000.0f;  // 基础拉力
    
    // 计算覆冰和风力造成的额外拉力
    float tension = base_tension;
    
    if (ice_thickness > 0.0f) {
        // 改进拉力计算公式，使其更符合物理规律
        // 覆冰重量与体积(厚度)成正比，与密度成正比
        float tension_per_mm = 9.5f * (ice_density / 600.0f);  // 微调系数为9.5
        float ice_tension = ice_thickness * tension_per_mm;
        
        // 考虑季节和阶段对拉力的影响
        if (g_simulation_data.current_season == SEASON_WINTER) {
            if (g_simulation_data.ice_phase == ICE_PHASE_GROWTH) {
                // 生长阶段，冰层松散，密度可能较低
                ice_tension *= 0.95f;
            } else if (g_simulation_data.ice_phase == ICE_PHASE_STABLE) {
                // 稳定阶段，冰层密实
                ice_tension *= 1.05f;
            } else if (g_simulation_data.ice_phase == ICE_PHASE_REDUCTION) {
                // 减少阶段，冰层松动
                ice_tension *= 0.90f;
            }
        }
        
        tension += ice_tension;
    }
    
    // 添加风力影响 - 考虑风向对拉力的影响
    float wind_tension = g_sensor_mock_data.wind_speed * g_sensor_mock_data.wind_speed * 0.22f;  // 微调系数为0.22
    
    // 根据风向调整风力影响 - 侧风和顺风的影响不同
    // 假设0度和180度是顺风/逆风，90度和270度是侧风
    float wind_angle = g_sensor_mock_data.wind_direction;
    while (wind_angle >= 180.0f) wind_angle -= 180.0f;  // 简化为0-180度
    
    // 侧风(90度)影响最大，顺/逆风(0/180度)影响较小
    float angle_factor = sinf(wind_angle * M_PI / 180.0f);
    wind_tension *= (0.8f + angle_factor * 0.4f);  // 0.8-1.2之间变化
    
    tension += wind_tension;
    
    // 添加两个传感器间的随机差异
    // 使用较小的差异，避免两个拉力值差距过大
    float random_factor1 = 1.0f + ((float)rand() / RAND_MAX * 0.03f - 0.015f);  // ±1.5%随机波动
    float random_factor2 = 1.0f + ((float)rand() / RAND_MAX * 0.03f - 0.015f);  // ±1.5%随机波动
    
    g_sensor_mock_data.tension1 = tension * random_factor1;
    g_sensor_mock_data.tension2 = tension * random_factor2;
    
    // 其他传感器参数 - 保持更加稳定的数值，减少大幅波动
    static float g_last_battery = 88.0f;  // 记录上次电池电量
    static float g_last_voltage = 23.7f;  // 记录上次电压
    static int g_last_signal = -70;       // 记录上次信号强度
    
    // 电池电量 - 缓慢随机波动
    float battery_target = 87.0f + ((float)rand() / RAND_MAX * 3.0f);  // 87-90%之间
    g_last_battery = g_last_battery * 0.95f + battery_target * 0.05f;  // 平滑过渡
    g_sensor_mock_data.battery_level = g_last_battery;
    
    // 电压 - 缓慢随机波动
    float voltage_target = 23.5f + ((float)rand() / RAND_MAX * 0.5f);  // 23.5-24.0V之间
    g_last_voltage = g_last_voltage * 0.95f + voltage_target * 0.05f;  // 平滑过渡
    g_sensor_mock_data.voltage = g_last_voltage;
    
    // 信号强度 - 缓慢随机波动
    int signal_target = -65 - (rand() % 10);  // -65到-75dBm之间
    g_last_signal = (int)(g_last_signal * 0.9f + signal_target * 0.1f);  // 平滑过渡
    g_sensor_mock_data.signal_strength = g_last_signal;
}

/**
 * @brief 同步传感器数据与环境模拟数据
 * 
 * 依据环境模拟数据更新传感器数据，确保两者保持一致
 * 
 * @param data 传感器数据指针
 */
void sync_sensor_data_with_simulation(SensorData *data) {
    if (!data) return;
    
    // 保存旧的传感器数据用于平滑变化计算
    static SensorData prev_data = {0};
    static int first_call = 1;
    
    // 第一次调用时初始化前值
    if (first_call) {
        memcpy(&prev_data, data, sizeof(SensorData));
        first_call = 0;
    }
    
    // 使用平滑系数进行数据过渡
    const float smooth_factor = 0.7f;  // 70%当前环境数据 + 30%旧传感器数据
    
    // 温度平滑变化 - 考虑季节和当前环境
    data->temperature = g_simulation_data.temperature * smooth_factor + 
                        prev_data.temperature * (1.0f - smooth_factor);
    
    // 湿度平滑变化 - 考虑季节和当前环境
    data->humidity = g_simulation_data.humidity * smooth_factor + 
                     prev_data.humidity * (1.0f - smooth_factor);
    
    // 风速平滑变化 - 有轻微随机波动
    float wind_random = ((float)rand() / RAND_MAX * 0.6f - 0.3f); // ±0.3m/s的随机波动
    data->wind_speed = g_simulation_data.wind_speed * smooth_factor + 
                       prev_data.wind_speed * (1.0f - smooth_factor) + wind_random;
    if (data->wind_speed < 0.0f) data->wind_speed = 0.0f;
    
    // 风向平滑变化 - 需要特殊处理以避免360°和0°之间的突变
    float target_direction = g_simulation_data.wind_direction;
    float current_direction = prev_data.wind_direction;
    
    // 计算最短角度差
    float direction_diff = target_direction - current_direction;
    if (direction_diff > 180.0f) direction_diff -= 360.0f;
    else if (direction_diff < -180.0f) direction_diff += 360.0f;
    
    // 应用平滑因子
    float new_direction = current_direction + direction_diff * smooth_factor;
    
    // 确保在0-360范围内
    if (new_direction < 0.0f) new_direction += 360.0f;
    else if (new_direction >= 360.0f) new_direction -= 360.0f;
    
    data->wind_direction = new_direction;
    
    // ============= 拉力计算 =============
    // 拉力计算基于冰厚度、冰密度、风速和环境条件
    
    // 1. 基础拉力 - 线缆自重
    const float base_tension = 3000.0f;  // 基础张力(N)
    
    // 2. 覆冰贡献的拉力 - 与厚度和密度相关
    // 不同季节和覆冰阶段对应不同的冰密度
    float ice_density = 850.0f;  // 默认冰密度(kg/m³)
    
    // 根据季节和温度调整冰密度
    if (g_simulation_data.temperature < -15.0f) {
        // 极低温下，冰密度更低(干雪/霜)
        ice_density = 650.0f + (float)rand() / RAND_MAX * 100.0f;
    } else if (g_simulation_data.temperature < -5.0f) {
        // 中等低温，普通冰
        ice_density = 800.0f + (float)rand() / RAND_MAX * 100.0f;
    } else {
        // 接近零度，可能含有水分的湿冰/雪
        ice_density = 880.0f + (float)rand() / RAND_MAX * 70.0f;
    }
    
    // 在覆冰增长阶段初期，密度较低(雪)；增长后期和稳定期，密度增加(冰)
    if (g_simulation_data.ice_phase == ICE_PHASE_GROWTH) {
        float phase_progress = g_simulation_data.real_ice_thickness / g_simulation_data.target_ice_thickness;
        if (phase_progress < 0.3f) {
            // 初期偏向雪的性质
            ice_density *= 0.85f;
        } else if (phase_progress > 0.7f) {
            // 后期偏向冰的性质
            ice_density *= 1.05f;
        }
    }
    
    // 计算冰的体积 - 假设冰均匀分布在圆柱体外表面(简化模型)
    const float LINE_DIAMETER = 20.0f;  // 导线直径(mm)
    const float LINE_LENGTH = 100.0f;   // 考虑的导线长度(m)
    
    // 冰厚度单位转换(mm→m)
    float ice_thickness_m = g_simulation_data.real_ice_thickness / 1000.0f;
    
    // 计算覆冰体积(m³)
    float ice_volume = 0.0f;
    if (ice_thickness_m > 0.0f) {
        float radius_with_ice = (LINE_DIAMETER/2000.0f + ice_thickness_m);
        float radius_line = LINE_DIAMETER/2000.0f;
        ice_volume = M_PI * (radius_with_ice * radius_with_ice - radius_line * radius_line) * LINE_LENGTH;
    }
    
    // 计算冰重量(N)
    const float GRAVITY = 9.8f;  // 重力加速度(m/s²)
    float ice_weight = ice_volume * ice_density * GRAVITY;
    
    // 3. 风荷载贡献的拉力
    // 计算风力系数 - 考虑覆冰后线缆的迎风面积增加
    float wind_area_factor = 1.0f;
    if (g_simulation_data.real_ice_thickness > 0.0f) {
        // 随着覆冰增厚，迎风面积增加
        wind_area_factor = 1.0f + g_simulation_data.real_ice_thickness / 20.0f; // 每20mm覆冰厚度增加100%迎风面积
    }
    
    // 风荷载与风速平方成正比
    float wind_force = 0.0f;
    if (data->wind_speed > 0.0f) {
        // 风力系数
        const float wind_coef = 0.8f;
        
        // 计算风荷载
        wind_force = wind_coef * wind_area_factor * data->wind_speed * data->wind_speed * LINE_LENGTH;
    }
    
    // 合计拉力 - 基础拉力 + 冰重量 + 风荷载
    float total_tension = base_tension + ice_weight + wind_force;
    
    // 添加两个传感器间的随机差异
    float random_factor1 = 1.0f + ((float)rand() / RAND_MAX * 0.06f - 0.03f);  // ±3%随机波动
    float random_factor2 = 1.0f + ((float)rand() / RAND_MAX * 0.06f - 0.03f);  // ±3%随机波动
    
    data->tension1 = total_tension * random_factor1;
    data->tension2 = total_tension * random_factor2;
    
    // 设置其他传感器数据 - 平滑变化
    // 电池电量 - 缓慢下降并偶尔小幅回升(模拟测量误差)
    static float battery_trend = 0.0f;
    battery_trend = battery_trend * 0.95f - 0.02f + ((float)rand() / RAND_MAX * 0.04f);
    data->battery_level = prev_data.battery_level + battery_trend;
    
    // 限制电池电量在合理范围
    if (data->battery_level > 100.0f) data->battery_level = 100.0f;
    if (data->battery_level < 10.0f) data->battery_level = 10.0f + ((float)rand() / RAND_MAX * 10.0f);
    
    // 电压 - 随电池电量变化但有稳定性
    data->voltage = 11.0f + data->battery_level / 100.0f * 2.0f + ((float)rand() / RAND_MAX * 0.1f - 0.05f);
    
    // 信号强度 - 随机波动但有稳定趋势
    static int signal_trend = 0;
    if (rand() % 10 == 0) {  // 10%概率改变趋势
        signal_trend = rand() % 3 - 1;  // -1, 0, 1
    }
    data->signal_strength = prev_data.signal_strength + signal_trend + (rand() % 3 - 1);
    
    // 限制信号强度在合理范围
    if (data->signal_strength > -50) data->signal_strength = -50 - (rand() % 5);
    if (data->signal_strength < -90) data->signal_strength = -90 + (rand() % 5);
    
    // 保存当前数据作为下次的前值
    memcpy(&prev_data, data, sizeof(SensorData));
}

/**
 * @brief 获取当前运行模式
 * 
 * @return RunMode 当前运行模式
 */
RunMode get_current_run_mode(void) {
    return g_run_mode;
}

/**
 * @brief 获取当前采样模式
 * 
 * @return SampleMode 当前采样模式
 */
SampleMode get_current_sample_mode(void) {
    return g_sample_mode;
}

/**
 * @brief 获取当前季节的视觉特征参数
 * 
 * 新增函数，用于模拟不同季节的视觉特征，影响摄像头图像
 * 
 * @param brightness 输出亮度系数(0.5-1.5)
 * @param contrast 输出对比度系数(0.8-1.2)
 * @param scene_color 输出场景色调(0=冷色调, 1=暖色调)
 * @param fog_density 输出雾气密度(0-1)
 * @param visible_range 输出可见距离系数(0.5-1.5)
 */
void get_season_visual_features(float *brightness, float *contrast, float *scene_color, 
                                float *fog_density, float *visible_range) {
    // 获取当前季节的基础参数
    SeasonType season = g_simulation_data.current_season;
    const SeasonParameters* season_params = &g_season_params[season];
    
    // 获取基础参数
    float base_brightness = season_params->brightness;
    float base_contrast = season_params->contrast;
    float base_scene_color = season_params->scene_color;
    float base_fog_density = season_params->fog_density;
    float base_visible_range = season_params->visible_range;
    
    // 添加随机变化，使每次图像不完全相同
    float random_range = 0.1f; // 10%的随机变化
    
    if (brightness) {
        *brightness = base_brightness + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * random_range;
        // 限制范围
        if (*brightness < 0.5f) *brightness = 0.5f;
        if (*brightness > 1.5f) *brightness = 1.5f;
    }
    
    if (contrast) {
        *contrast = base_contrast + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * (random_range * 0.5f);
        // 限制范围
        if (*contrast < 0.8f) *contrast = 0.8f;
        if (*contrast > 1.2f) *contrast = 1.2f;
    }
    
    if (scene_color) {
        *scene_color = base_scene_color + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * (random_range * 0.5f);
        // 限制范围
        if (*scene_color < 0.0f) *scene_color = 0.0f;
        if (*scene_color > 1.0f) *scene_color = 1.0f;
    }
    
    if (fog_density) {
        *fog_density = base_fog_density + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * (random_range * 0.8f);
        // 限制范围
        if (*fog_density < 0.0f) *fog_density = 0.0f;
        if (*fog_density > 1.0f) *fog_density = 1.0f;
        
        // 冬季覆冰阶段额外影响
        if (season == SEASON_WINTER && g_simulation_data.ice_phase == ICE_PHASE_GROWTH) {
            *fog_density += 0.2f; // 覆冰增长阶段雾气更浓
            if (*fog_density > 1.0f) *fog_density = 1.0f;
        }
    }
    
    if (visible_range) {
        *visible_range = base_visible_range + ((float)rand() / RAND_MAX * 2.0f - 1.0f) * (random_range * 0.8f);
        // 限制范围
        if (*visible_range < 0.5f) *visible_range = 0.5f;
        if (*visible_range > 1.5f) *visible_range = 1.5f;
        
        // 环境条件影响可见度
        if (g_simulation_data.wind_speed > 10.0f) {
            *visible_range *= 0.8f; // 大风降低可见度
        }
        if (g_simulation_data.humidity > 90.0f) {
            *visible_range *= 0.7f; // 高湿度降低可见度
        }
    }
}

// 重命名这两个函数以避免冲突
static void update_simulation_visual_data(SimulationData *data) {
    const int delay_milliseconds = 200 + rand() % 50;
    
    // 模拟处理延迟
    usleep(delay_milliseconds);
    
    if (data == NULL) {
        return;
    }
    
    // 确保厚度非负
    float actual_thickness = data->equivalent_ice_thickness;
    if (actual_thickness < 0.0f) {
        actual_thickness = 0.0f;
    }
    
    // 缩小视觉测量的随机误差范围
    float max_error_percentage = 0.08f;
    
    // 记录前一个值用于平滑处理
    static float prev_visual_thickness = 0.0f;
    float visual_thickness = 0.0f;
    
    // 针对小厚度值特殊处理，避免负值
    if (actual_thickness < 0.5f) {
        max_error_percentage = 0.03f;
        
        // 厚度很小时只添加正向误差
        float error = ((float)rand() / RAND_MAX) * max_error_percentage * actual_thickness;
        visual_thickness = actual_thickness + error;
    } else {
        // 正常厚度时的随机误差
        float error = ((float)rand() / RAND_MAX * 2.0f - 1.0f) * max_error_percentage * actual_thickness;
        visual_thickness = actual_thickness + error;
        
        // 确保不会为负
        if (visual_thickness < 0.01f) {
            visual_thickness = 0.01f + ((float)rand() / RAND_MAX * 0.01f);
        }
    }
    
    // 平滑处理，确保视觉厚度值变化不会太大
    if (prev_visual_thickness > 0.01f) {
        float change = visual_thickness - prev_visual_thickness;
        if (fabs(change) > MAX_THICKNESS_CHANGE) {
            float change_dir = (change > 0) ? 1.0f : -1.0f;
            visual_thickness = prev_visual_thickness + change_dir * MAX_THICKNESS_CHANGE;
        }
    }
    
    prev_visual_thickness = visual_thickness;
    
    // 更新结构体中对应的字段 - 使用real_ice_thickness替代不存在的visual_thickness
    data->real_ice_thickness = visual_thickness;
}

static void update_simulation_stereo_data(SimulationData *data) {
    const int delay_milliseconds = 150 + rand() % 40;
    
    // 模拟处理延迟
    usleep(delay_milliseconds);
    
    if (data == NULL) {
        return;
    }
    
    // 确保厚度非负
    float actual_thickness = data->equivalent_ice_thickness;
    if (actual_thickness < 0.0f) {
        actual_thickness = 0.0f;
    }
    
    // 缩小立体视觉测量的随机误差范围
    float max_error_percentage = 0.05f;
    
    // 记录前一个值用于平滑处理
    static float prev_stereo_thickness = 0.0f;
    float stereo_thickness = 0.0f;
    
    // 针对小厚度值特殊处理，避免负值
    if (actual_thickness < 0.5f) {
        max_error_percentage = 0.02f;
        
        // 厚度很小时只添加正向误差
        float error = ((float)rand() / RAND_MAX) * max_error_percentage * actual_thickness;
        stereo_thickness = actual_thickness + error;
    } else {
        // 正常厚度时的随机误差
        float error = ((float)rand() / RAND_MAX * 2.0f - 1.0f) * max_error_percentage * actual_thickness;
        stereo_thickness = actual_thickness + error;
        
        // 确保不会为负
        if (stereo_thickness < 0.01f) {
            stereo_thickness = 0.01f + ((float)rand() / RAND_MAX * 0.01f);
        }
    }
    
    // 平滑处理，确保立体视觉厚度值变化不会太大
    if (prev_stereo_thickness > 0.01f) {
        float change = stereo_thickness - prev_stereo_thickness;
        if (fabs(change) > MAX_THICKNESS_CHANGE) {
            float change_dir = (change > 0) ? 1.0f : -1.0f;
            stereo_thickness = prev_stereo_thickness + change_dir * MAX_THICKNESS_CHANGE;
        }
    }
    
    prev_stereo_thickness = stereo_thickness;
    
    // 视觉数据已经存储在real_ice_thickness中，处理视觉和立体视觉数据的比较
    float visual_thickness = data->real_ice_thickness;
    float diff = fabs(visual_thickness - stereo_thickness);
    float max_allowed_diff = actual_thickness * 0.06f;
    
    if (max_allowed_diff < 0.1f) {
        max_allowed_diff = 0.1f;
    }
    
    if (diff > max_allowed_diff) {
        // 计算平均值
        float avg = (visual_thickness + stereo_thickness) / 2.0f;
        
        // 将两个值调整为彼此更靠近
        if (visual_thickness > stereo_thickness) {
            data->real_ice_thickness = avg + max_allowed_diff / 2.0f;
            stereo_thickness = avg - max_allowed_diff / 2.0f;
        } else {
            data->real_ice_thickness = avg - max_allowed_diff / 2.0f;
            stereo_thickness = avg + max_allowed_diff / 2.0f;
        }
    }
    
    // 由于没有专门存储立体视觉厚度的字段，使用target_ice_thickness字段
    // 或者使用静态变量保存此值（不会产生警告）
    static float last_stereo_thickness __attribute__((unused)) = 0.0f;
    last_stereo_thickness = stereo_thickness;  // 保存立体视觉测量的厚度值
}